Ignore this PR until it has been reviewed by @ChrisRackauckas.

Summary

FunctionWrappersWrapper is exported, so its two-argument inner constructor was already reachable as public API — but it was the only constructor of the type carrying no docstring. The other three all have one.

That matters because it is the constructor downstream solver stacks actually call. NonlinearSolveBase's AutoDePSpecialize / norecompile path builds its wrapper tuple itself and then constructs with all three type parameters supplied directly:

cs = FunctionWrappersWrappers.SingleCacheStorage()
FunctionWrappersWrappers.FunctionWrappersWrapper{
    typeof(fwt), FunctionWrappersWrappers.AllowNonIsBits, typeof(cs),
}(fwt, cs)

It uses this form rather than FunctionWrappersWrapper(fwt; cache, policy) because giving FW, P and CS as type parameters makes the wrapper type inferrable without depending on constant propagation through a keyword-argument frame — and the wrapper type, plus every cache built from the wrapped problem, has to stay concrete. The docstring now records that, and records the caller's obligation to keep cs consistent with the cache mode P's fallback path expects.

Note on mechanics: a docstring written inside the struct body does not attach to the type's binding — I verified it does not show up in the binding's MultiDoc, so Documenter would never render it. It has to be attached with @doc on the method signature after the struct.

Docs-only; no behavior change. Patch bump to 1.11.1 — the name was already public and exported, this only documents an existing method.

Validation

Docstring is attached to the right method, alongside the four pre-existing ones:

$ julia --project -e '...Base.Docs.meta(FunctionWrappersWrappers)[b].docs...'
docstring count: 5
  sig=…Tuple{FW, CS}} where {FW, P, CS}  -> FunctionWrappersWrapper{FW, P, CS}(fw, cs) -> FunctionWrappersWrapper{FW, P, CS}
  sig=…Tuple{F, NTuple{K, Any}, NTuple{K, Type}}} where {F, K}  -> FunctionWrappersWrapper(f, argtypes, rettypes; …
  sig=…Tuple{Any}…  -> FunctionWrappersWrapper{FW, P, CS}(f) -> …
  sig=Union{}  -> FunctionWrappersWrapper{FW, P, CS}
  sig=Tuple{Tuple{Vararg{FunctionWrappers.FunctionWrapper}}}  -> FunctionWrappersWrapper(fw::…; cache=…, policy=…)

The new jldoctest was run directly and returns 3.0 as written.

Full test suite passes:

$ julia --project -e 'using Pkg; Pkg.test()'
     Testing FunctionWrappersWrappers tests passed

Runic 1.7.0 --check exits 0.

CI

The QA group was failing here for a reason unrelated to this change: #76 dropped the ExplicitImports ignore list, and main has been red since. This PR is stacked on #80, which fixes that. Merge #80 first.

$ GROUP=QA julia --project=. -e 'using Pkg; Pkg.test()'   # this branch, on top of #80
QA            |   20     20  29.3s
     Testing FunctionWrappersWrappers tests passed

Correction to the validation note above: my earlier Pkg.test() run exercised only the curated default group, which does not include QA, so it did not catch that failure.

Rebased after #80 grew a second commit removing the dead TruncatedStacktraces dependency — the @doc block now sits directly after the struct rather than after the TruncatedStacktraces.@truncate_stacktrace line, which no longer exists. Re-verified the docstring still attaches to the right method: the binding carries 5 docstrings, the new one keyed on Tuple{FW, CS}.

Links

• Consumer: Reach the AutoDePSpecialize wrappers through public APIs NonlinearSolve.jl#1124
• 1.11.0 registration (merged): New version: FunctionWrappersWrappers v1.11.0 JuliaRegistries/General#162490
• Stacked on: Fix the QA regression from #76 and drop the dead TruncatedStacktraces dependency #80